package com.chenziwen.scala.chapter08

object Scala14_Ext {
  def main(args: Array[String]): Unit = {
    // 拉链函数(List((1,4), (2,5)))
    val list1 = List(1, 2, 3)
    val list2 = List(4, 5)

    val list3 = list1 zip list2
    println(list3)

    // 迭代器
    val it = List(1, 2, 3, 4, 5).iterator
    while (it.hasNext) {
      println(it.next())
    }

    for (item <- it) {
      println(item)
    }

    //  流:Stream是一个集合，可以用于存放，无穷多个元素，但是这个无穷个元素并不是会一次性生产出来，而是需要用到多大的空间，就会动态生成，末尾元素遵循lazy加载规则
    //  注意：千万不要直接调用stream.last方法，这样会导致死循环
    def numsForm(n: BigInt): Stream[BigInt] = n #:: numsForm(n + 1)

    val stream1 = numsForm(1)
    println(stream1)
    println(stream1.head)
    // tail的每一次使用，都会动态的向stream集合按照规则生成新的元素
    println(stream1.tail)
    println(stream1.tail.head)
    //println(stream1.last)

    def multi(i: BigInt): BigInt = {
      i * i
    }

    println(numsForm(5).map(multi))

    // View:该方法产生出一个其方法总是被懒执行的集合。但是view不会缓存数据，每次都要重新计算
    def multiple(num: Int): Int = {
      num
    }

    def eq(i: Int): Boolean = {
      i.toString.equals(i.toString.reverse)
    }

    val viewSquares = (1 to 100)
      .view
      .map(multiple)
      .filter(eq)
    // 增加了view后，该集合会被懒加载，所以该集合为：SeqViewMF(...)
    // 当不带view视图的时候，该集合为：Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99)
    println(viewSquares)
    for (x <- viewSquares) {
      print(x + "，")
    }


    // 并行集合
    (1 to 5).foreach(println(_))
    // 添加一个par，就能让集合变成一个并行集合
    (1 to 5).par.foreach(println(_))

    val result1 = (0 to 100).map { case _ => Thread.currentThread.getName }.distinct
    val result2 = (0 to 100).par.map { case _ => Thread.currentThread.getName }.distinct
    println(result1)
    println(result2)

    // 操作符
    val op = new Operate14
    // 无参函数可以省略小括号
    // 1.如果不省略，调用函数时，小括号可以省略，也可以不省略
    // 2.如果省略，调用函数时，必须省略，为了访问的一致性
    op++

    !op
  }
}

class Operate14 {
  def ++ = println("++")

  // 声明前置运算符(运算符前需要用：unary_修饰)
  def unary_! = println("!!!!!")
}